package com.example.demo.controller;

import com.example.demo.pojo.*;
import com.example.demo.server.FriendsServer;
import com.example.demo.server.ReqMessageServer;
import com.example.demo.server.UserServer;
import com.example.demo.utils.TokenTool;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.ExampleObject;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.List;

/**
 * 好友请求消息的Controller , 用于 , 处理请求消息 , 并进行加好友的操作
 *
 * @author 刘二朋
 * @date 2020-12-02 14:11
 */
@RestController
@RequestMapping("/request")
@Tag(name = "请求管理", description = "处理用户的请求消息 , 进行互相加好友的操作 ,删除好友的关系")
@CrossOrigin(origins = "*")//解决跨域问题
public class RequestController {

    //    指定装配一个 UserServer对象 , 用于操作用户的数据
    @Autowired
    UserServer userServer;

    @Autowired
    FriendsServer friendsServer;

    @Autowired
    ReqMessageServer reqMessageServer;


    /**
     * 客户端向服务端发送请求 , 用于保存好友请求消息 ,
     * 服务端拿到请求 , 判断 , 与该用户是否是好友关系 , 并给出响应的反馈
     *
     * @param user    要进行操作的用户
     * @param request 当前登录的用户的信息 , 用于获取用户的账号
     * @return 返回处理的结果 , 并响应的对应的客户端 , 进行展示
     */
    @PostMapping("/addRequest")
    @ResponseBody
    @Operation(summary = "添加请求消息",
            responses = {
                    @ApiResponse(
                            responseCode = "2000",
                            description = "请求消息 , 发送成功",
                            content = @Content(
                                    mediaType = "application/json",
                                    examples = @ExampleObject(description = "data数据为：", value = "{\n" +
                                            "  \"code\": 2000,\n" +
                                            "  \"message\": \"请求消息 , 发送成功！\",\n" +
                                            "  \"data\": {\n" +
                                            "    \"user\": {\n" +
                                            "      \"id\": 13123456781,\n" +
                                            "    },\n" +
                                            "  }\n" +
                                            "}")
                            )),
                    @ApiResponse(responseCode = "2001", description = "请求消息 , 发送失败")
            })
    public Message addRequest(@RequestBody SigIn user, HttpServletRequest request) {
        Message message = new Message();
//        获取 , 请求中Token中 , 用户的账号的信息
        String tokenUserId = TokenTool.getTokenUserId(request);
//        判断 , 两个用户 , 是否已经是:
        List<Friends> friends = friendsServer.RequestaAndRequestb(user.getId(), tokenUserId);
//       判断搜索到的用户列表 , 是否为空 , 如果为空 , 则返回true
        if (friends.isEmpty()) {
//            没有好友关系 , 则进行添加好友(保存 , 请求消息)
            Reqmessage reqmessage = reqMessageServer.addReqmessage(tokenUserId, user.getId(), user.getName());
            if (reqmessage == null) {
                message.setErrorMessage("好友申请 , 发送失败").setCode(3);
                return message;
            } else {
                message.setSuccessMessage("好友申请 , 发送成功");
                return message;
            }
        } else {
//            不为空 , 则存在好友列表 , 则取消添加
            message.setErrorMessage("用户已存在到好友列表").setCode(3);
            return message;
        }
    }

    /**
     * 客户端向服务端发送一个 获取指定用户的所有的请求消息 ,
     * 并把用户的所有的请求消息 , 返回到对应的客户端 , 进行展示
     *
     * @param request 客户端的请求对象
     * @return 返回查询到的请求列表
     */
    @GetMapping("/selectRequest")
    @ResponseBody
    @Operation(summary = "获取请求消息",
            responses = {
                    @ApiResponse(
                            responseCode = "2000",
                            description = "请求消息 , 发送成功",
                            content = @Content(
                                    mediaType = "application/json",
                                    examples = @ExampleObject(description = "data数据为：", value = "{\n" +
                                            "  \"code\": 2000,\n" +
                                            "  \"message\": \"请求消息 , 获取成功！\",\n" +
                                            "  \"data\": {\n" +
                                            "    \"user\": {\n" +
                                            "      \"id\": 13123456781,\n" +
                                            "    },\n" +
                                            "  }\n" +
                                            "}")
                            )),
                    @ApiResponse(responseCode = "2001", description = "请求消息 , 发送失败")
            })
    public Message selectRequest(HttpServletRequest request) {
// 创建一个消息对象
        Message message = new Message();
//        重Token里面 , 获取到当前登录的用户的信息
        String tokenUserId = TokenTool.getTokenUserId(request);
//        根据账号 获取 , 指定用户的所有的请求消息
        List<Reqmessage> reqmessages = reqMessageServer.selectRequestmessage(tokenUserId);
        if (reqmessages.isEmpty()) {
//            没有数据 ,
            message.setSuccessMessage("好友列表 , 展示成功");
            return message;
        } else {
            //            创建一个集合,  来保存用户返回的请求消息
            List<User> requests = new ArrayList<>();
//            得到请求列表 , 则遍历 用户的朋友列表 , 将用户的朋友列表 , 进行封装 , 发送到对应的客户端,  进行展示
            for (int i = 0; i < reqmessages.size(); i++) {
//               得到被请求者的账号 , 通过用户的账号 , 来查询用户的信息
//                查询到用户的基本信息
                User user = userServer.fromById(reqmessages.get(i).getRequesta());
//                设置用户的密码 , 当成请求的消息内容
                user.setPassword(reqmessages.get(i).getMessage());

//                创建一个用户对象
                User user1 = new User();
                user1.setId(user.getId());
                user1.setName(user.getName());
                user1.setAvater(user.getAvater());
                user1.setPassword(reqmessages.get(i).getMessage());
//                System.out.println(reqmessages.get(i).getMessage());
//                把请求的信息 , 保存到集合里面 , 并把响应返回到对应的客户端
                requests.add(user1);
            }
//            System.out.println(requests);
            message.setSuccessMessage("好友列表 , 获取成功").put("user", requests);
            return message;
        }
    }

    /**
     * 同意用户的请求的接口 , 用于互相加好友
     *
     * @param user    要进行操作的用户
     * @param request 获取当前操作的用户
     * @return 返回 , 操作的结果
     */
    @PostMapping("/consent")
    @ResponseBody
    @Operation(summary = "同意请求消息",
            responses = {
                    @ApiResponse(
                            responseCode = "2000",
                            description = "同意消息 , 成功",
                            content = @Content(
                                    mediaType = "application/json",
                                    examples = @ExampleObject(description = "data数据为：", value = "{\n" +
                                            "  \"code\": 2000,\n" +
                                            "  \"message\": \"同意请求消息 , 成功！\",\n" +
                                            "  \"data\": {\n" +
                                            "    \"user\": {\n" +
                                            "      \"id\": 13123456781,\n" +
                                            "    },\n" +
                                            "  }\n" +
                                            "}")
                            )),
                    @ApiResponse(responseCode = "2001", description = "同意请求消息 , 好友添加失败")
            })
    public Message consent(@RequestBody SigIn user, HttpServletRequest request) {
//        创建一个Message对象
        Message message = new Message();
        //        重Token里面 , 获取到当前登录的用户的信息
        String tokenUserId = TokenTool.getTokenUserId(request);
//        判断 , 两个用户 , 是否是互相为好友
        List<Friends> friends = friendsServer.RequestaAndRequestb(user.getId(), tokenUserId);
        if (friends.isEmpty()) {
//            互相不是好友,  则进行添加好友 , 向朋友列表添加一条消息
            friendsServer.addFriends(user.getId(), tokenUserId);
            friendsServer.addFriends(tokenUserId, user.getId());
//            删除互相的请求消息
            reqMessageServer.deleteReqMessage(tokenUserId, user.getId());
//            互相加好友 , 则向客户端  , 发送一个成功的反馈
            message.setSuccessMessage("用户添加成功");
            return message;
        }
        message.setErrorMessage("用户已存在到好友列表").setCode(3);
        return message;
    }


    /**
     * 拒绝用户的请求 , 用于将用户的请求信息 , 删除 ,
     *
     * @param user    要操作的用户
     * @param request 当前登录的用户的信息
     * @return 返回操作的结果
     */
    @PostMapping("/refuse")
    @ResponseBody
    @Operation(summary = "同意请求消息",
            responses = {
                    @ApiResponse(
                            responseCode = "2000",
                            description = "拒绝消息 , 成功",
                            content = @Content(
                                    mediaType = "application/json",
                                    examples = @ExampleObject(description = "data数据为：", value = "{\n" +
                                            "  \"code\": 2000,\n" +
                                            "  \"message\": \"拒绝请求消息 , 成功！\",\n" +
                                            "  \"data\": {\n" +
                                            "    \"user\": {\n" +
                                            "      \"id\": 13123456781,\n" +
                                            "    },\n" +
                                            "  }\n" +
                                            "}")
                            )),
                    @ApiResponse(responseCode = "2001", description = "拒绝请求消息 , 好友添加失败")
            })
    public Message refuse(@RequestBody SigIn user, HttpServletRequest request) {
        Message message = new Message();
        //        重Token里面 , 获取到当前登录的用户的信息
        String tokenUserId = TokenTool.getTokenUserId(request);
        reqMessageServer.deleteReqMessage(tokenUserId, user.getId());
        message.setSuccessMessage("已拒绝该用户的请求消息成功");
        return message;
    }


}
